#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include "logger.hpp"


typedef websocketpp::server<websocketpp::config::asio> server_t;
//连接的类型 server_t::connection_ptr


class Connection
{
    public:
        struct Client
        {
            Client(const std::string& u,const std::string& s) :uid(u),ssid(s) {}
            std::string uid;
            std::string ssid;
        };
        using ptr = std::shared_ptr<Connection>;
        Connection() {}
        ~Connection() {}
            
        //添加长连接用户信息
        void insert(const server_t::connection_ptr& conn,const std::string& uid,const std::string& ssid)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _uid_connection.insert(std::make_pair(uid,conn));
            _conn_clients.insert(std::make_pair(conn,Client(uid,ssid)));
            LOG_DEBUG("新增长连接用户信息: {}-{}-{}",(size_t)conn.get(),uid,ssid);
        }

        //获取长连接
        server_t::connection_ptr connection(const std::string& uid) {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _uid_connection.find(uid);
            if(it == _uid_connection.end())
            {
                LOG_ERROR("未找到 {} 客户端的长连接",uid);
                return server_t::connection_ptr();
            }

            LOG_DEBUG("找到了对应的客户端长连接 {}",uid);
            return it->second;
        }

        //获取对应长连接客户端的信息
        bool client(const server_t::connection_ptr& conn,std::string& uid, std::string& ssid)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _conn_clients.find(conn);
            if(it == _conn_clients.end())
            {
                LOG_ERROR("没有找到对应长连接的客户端信息 {}",(size_t)conn.get());
                return false;
            }
            
            uid = it->second.uid;
            ssid = it->second.ssid;
            LOG_DEBUG("找到 {} 客户端的长连接",uid);
            return true;
        }

        //删除对应的长连接
        void remove(const server_t::connection_ptr& conn)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _conn_clients.find(conn);
            if(it == _conn_clients.end())
            {
                LOG_ERROR("没有找到对应的客户端信息，无法删除 {}",(size_t)conn.get());
            }

            _uid_connection.erase(it->second.uid);
            _conn_clients.erase(it);
            LOG_DEBUG("删除长连接信息完成");
        }

    private:
    std::mutex _mutex; 
    //通过uid 可以找到对应的长连接
    unordered_map<std::string,server_t::connection_ptr> _uid_connection;
    //通过长连接 可以找到对应的客户端的uid 和 ssid
    unordered_map<server_t::connection_ptr,Client> _conn_clients;
};
